﻿//using System;
//using System.Diagnostics;

//namespace NLite
//{
//    [Serializable]
//    [DebuggerDisplay("Id='{Id}', Type = '{Type}'")]
//    public struct Key : IEquatable<Key>,IKey<string>
//    {
//        private RuntimeTypeHandle handle;
//        private string name;

//        private Key(RuntimeTypeHandle type, string name)
//        {
//            this.handle = type;
//            this.name = !string.IsNullOrEmpty(name) ? name : null;
//        }

//        private Key(RuntimeTypeHandle type)
//            : this(type, null)
//        {
//        }

//        /// <summary>
//        /// 通过类型得到一个Key
//        /// </summary>
//        /// <param name="type"></param>
//        /// <returns></returns>
//        public static Key Make(Type type)
//        {
//            if (type == null)
//                throw new ArgumentNullException("type");
//            return new Key(type.TypeHandle, null);
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        /// <param name="type"></param>
//        /// <param name="name"></param>
//        /// <returns></returns>
//        public static Key Make(Type type, string name)
//        {
//            if (type == null)
//                throw new ArgumentNullException("type");
//            return new Key(type.TypeHandle, name);
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        /// <typeparam name="TTarget"></typeparam>
//        /// <returns></returns>
//        public static Key Make<T>()
//        {
//            return new Key(typeof(T).TypeHandle, null);
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        /// <typeparam name="TTarget"></typeparam>
//        /// <param name="name"></param>
//        /// <returns></returns>
//        public static Key Make<T>(string name)
//        {
//            return new Key(typeof(T).TypeHandle, name);
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        public RuntimeTypeHandle Handle
//        {
//            get { return handle; }
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        public string Name
//        {
//            get { return name; }
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        public Type Type
//        {
//            get { return Type.GetTypeFromHandle(handle); }
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        public string Id
//        {
//            get
//            {
//                return string.IsNullOrEmpty(Name) ? Type.Name : Name;
//            }
//        }

//        public override bool Equals(object obj)
//        {
//            return Equals((Key)obj);
//        }


//        public override int GetHashCode()
//        {
//            int typeHash = handle == null ? 0 : handle.GetHashCode();
//            int nameHash = Id.GetHashCode();
//            return typeHash ^ nameHash;
//        }


//        public static bool operator ==(Key left, Key right)
//        {
//            if (left != null)
//                return left.Equals(right);
//            return false;
//        }


//        public static bool operator !=(Key left, Key right)
//        {
//            return !(left == right);
//        }


//        public override string ToString()
//        {
//            return string.IsNullOrEmpty(Name) ? Type.Name : Name;
//        }

//        public bool Equals(Key other)
//        {
//            if (other == null)
//                return false;
//            return handle.Equals(other.handle)
//                && string.Compare(Id, other.Id, StringComparison.InvariantCulture) == 0;
//        }
//    }
//}